﻿//#include<iostream>
//
//using namespace std;

//class Date
//{
//public:
//
//	////1.无参构造函数
//	//Date()
//	//{
//	//	_year = 2005;
//	//	_month = 8;
//	//	_day = 23;
//	//}
//
//	////2.带参构造函数
//	//Date(int year, int month, int day)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//	
//	//3.全缺省构造函数
//	Date(int year = 2000, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1;
//	Date d2(2025);
//	Date d3(2025, 3, 10);
//
//	d1.Print();
//	d2.Print();
//	d3.Print();
//
//	return 0;
//}

//typedef int STDataType;
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//private:
//	STDataType* _a;
//	int _capacity;
//	int _top;
//};
//
//// 两个Stack实现队列
//class MyQueue
//{
//public:
//	//编译器默认生成MyQueue的构造函数（无参）调⽤了Stack的构造，完成了两个成员的初始化
//private:
//	Stack pushst;
//	Stack popst;
//};
//int main()
//{
//	//error C2665: “MyQueue::MyQueue”: 没有重载函数可以转换所有参数类型
//	MyQueue mq;
//	return 0;
//}

//typedef int STDataType;
//
//class Stack
//{
//public:
//
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//
//private:
//	STDataType* _a;
//	int _capacity;
//	int _top;
//};
//
//// 两个Stack实现队列
//class MyQueue
//{
//public:
//	//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
//	// 显⽰写析构，也会⾃动调⽤Stack的析构
//	~MyQueue()
//	{
//		cout << "~MyQueue()" << endl;
//	}
//private:
//	Stack pushst;
//	Stack popst;
//};
//
//int main()
//{
//	Stack st;	//析构一次
//
//	MyQueue mq;	//析构两次
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 2000, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//bool operator == (Date d1, Date d2)
//{
//	return d1._year == d2._year
//		&& d1._month == d2._month
//		&& d1._day == d2._day;
//}
//
//int main()
//{
//	Date d1, d2(2025);
//
//	if (d1 == d2)
//		cout << "等于" << endl;
//	else
//		cout << "不等于" << endl;
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 2000, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//	bool operator == (Date d)
//	{
//		return _year == d._year
//			&& _month == d._month
//			&& _day == d._day;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1, d2(2025);
//
//	if (d1 == d2)
//		cout << "等于" << endl;
//	else
//		cout << "不等于" << endl;
//
//	return 0;
//}

#include<iostream>

using namespace std;

//class Date
//{
//public:
//	//构造函数
//	Date(int year = 2000, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//void Func1(Date d2)
//{
//	d2.Print();
//}
//
//int main()
//{
//	Date d1(2025,3,10);
//
//	//对象拷贝要要调用拷贝构造
//	Date d2(d1);
//
//	//传值传参要调用拷贝构造
//	Func1(d2);	//调用（编译器自动生成的）拷贝构造函数
//
//	return 0;
//}

//typedef int STDataType;
//
//class Stack
//{
//public:
//	//构造函数
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc failed!");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//	//析构函数
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	} 
//	void Push(STDataType x)
//	{
//		if (_top == _capacity)
//		{
//			int newcapacity = _capacity * 2;
//			STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
//			if (tmp == NULL)
//			{
//				perror("realloc fail");
//				return;
//			}
//			_a = tmp;
//			_capacity = newcapacity;
//		}
//		_a[_top++] = x;
//	}
//	//拷贝构造函数
//	Stack(const Stack& st)
//	{
//		// 需要对_a指向资源创建同样大的资源再拷贝值
//		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
//		if (nullptr == _a)
//		{
//			perror("malloc failed!");
//			return;
//		}
//		memcpy(_a, st._a, sizeof(STDataType) * st._top);
//		_top = st._top;
//		_capacity = st._capacity;
//	}
//private:
//	STDataType* _a;
//	int _capacity;
//	int _top;
//};

//// 两个Stack实现队列
//class MyQueue
//{
//public:
//private:
//	Stack pushst;
//	Stack popst;
//};
//
//void func(MyQueue mq)
//{
//	//...
//}
//
//int main()
//{
//	MyQueue mq1,mq2;	// 调用MyQueue的构造函数 -> 分别调用两个Stack的构造函数
//	
//	mq2 = mq1;
//
//	func(mq2);	// 调用MyQueue的拷贝构造 -> 分别调用两个Stack的拷贝构造
//				// 调用MyQueue的析构函数 -> 分别调用两个Stack的析构函数
//				// （析构四次：两个构造的Stack和两个拷贝构造的Stack）
//	return 0;
//}

//typedef int STDataType;
//
//class Stack
//{
//public:
//	//构造函数
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc failed!");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//	//析构函数
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//	void Push(STDataType x)
//	{
//		if (_top == _capacity)
//		{
//			int newcapacity = _capacity * 2;
//			STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
//			if (tmp == NULL)
//			{
//				perror("realloc fail");
//				return;
//			}
//			_a = tmp;
//			_capacity = newcapacity;
//		}
//		_a[_top++] = x;
//	}
//	//拷贝构造函数
//	Stack(const Stack& st)
//	{
//		// 需要对_a指向资源创建同样大的资源再拷贝值
//		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
//		if (nullptr == _a)
//		{
//			perror("malloc failed!");
//			return;
//		}
//		memcpy(_a, st._a, sizeof(STDataType) * st._top);
//		_top = st._top;
//		_capacity = st._capacity;
//	}
//private:
//	STDataType* _a;
//	int _capacity;
//	int _top;
//};
//
//Stack& func()
//{
//	static Stack st;
//
//	return st;	//调用Stack的拷贝构造
//}
//
//int main()
//{
//	Stack ret = func();	//将拷贝构造的值返回给ret
//	ret.Push(1);
//
//	return 0;
//}

//#include<iostream>
//
//using namespace std;

//class Date
//{
//public:
//	Date(int year = 2000, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//
//		_day = day;
//	}
//	const Date& operator = (const Date& d)	//返回值和参数都建议写成引用（）
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//		//this指针指向的是左侧运算对象的地址
//		return *this;	//解引用后代表左侧运算对象
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1, d2(2025,3,12), d3(2005, 8, 23);
//
//	cout << "d1："; d1.Print();
//	cout << "d2："; d2.Print();
//	cout << "d3："; d3.Print();
//
//	d1 = d2 = d3;	// (d1 = (d2 = d3));
//	// (d2 = d3)的返回值是d2，(d1 = d2)的返回值是d1
//	cout << endl;
//
//	cout << "d1："; d1.Print();
//	cout << "d2："; d2.Print();
//	cout << "d3："; d3.Print();
//
//	return 0;
//}

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// void Print(const Date* const this)
	void Print() const
	{
		//error C3490 : 由于正在通过常量对象访问“_year”，因此无法对其进行修改
		//error C3490 : 由于正在通过常量对象访问“_month”，因此无法对其进行修改
		//error C3490: 由于正在通过常量对象访问“_day”，因此无法对其进行修改
		//this->_year = 0; this->_month = 0; this->_day = 0;
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	// 这里非const对象也可以调用const成员函数是一种权限的缩小
	Date d1(2025, 3, 13);
	d1.Print();

	const Date d2(2025, 4, 12);
	d2.Print();

	return 0;
}